package com.ruoyi.utils.ID;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.cs.event.customerEvent.mapper.CustomerEventMapper;
import com.ruoyi.cs.event.customeroffer.mapper.CustomerOfferMapper;
import com.ruoyi.cs.event.followRecord.mapper.FollowRecordMapper;
import com.ruoyi.cs.event.supplieroffer.mapper.SupplierOfferMapper;
import com.ruoyi.personnel.oa.file.mapper.FileMapper;
import com.ruoyi.personnel.oa.leave.mapper.LeaveMapper;
import com.ruoyi.produce.base.offer.mapper.ProduceOfferMapper;
import com.ruoyi.produce.material.mapper.ProduceMaterialMapper;
import com.ruoyi.produce.process.costAccounting.mapper.CostAccountingMapper;
import com.ruoyi.produce.process.costApportionment.mapper.CostApportionmentMapper;
import com.ruoyi.produce.process.planoutsource.mapper.ProducePlanOutsourceMapper;
import com.ruoyi.produce.process.planself.mapper.ProducePlanSelfMapper;
import com.ruoyi.produce.process.receiving.mapper.ReceivingReportMapper;
import com.ruoyi.psi.inventory.record.mapper.StockInRecordMapper;
import com.ruoyi.produce.process.worksheet.mapper.ProduceWorkSheetMapper;
import com.ruoyi.psi.inventory.check.mapper.InventoryCheckMapper;
import com.ruoyi.psi.inventory.in.mapper.InventoryInMapper;
import com.ruoyi.psi.inventory.out.mapper.InventoryOutMapper;
import com.ruoyi.psi.inventory.recordOut.mapper.StockOutRecordMapper;
import com.ruoyi.psi.inventory.transfer.mapper.InventoryTransferMapper;
import com.ruoyi.psi.purchase.apply.mapper.PurchaseApplyMapper;
import com.ruoyi.psi.purchase.order.mapper.PurchaseOrderMapper;
import com.ruoyi.psi.purchase.pay.mapper.PurchasePayMapper;
import com.ruoyi.psi.purchase.purchasereturn.mapper.PurchaseReturnMapper;
import com.ruoyi.psi.purchase.storage.mapper.PurchaseStorageMapper;
import com.ruoyi.psi.quality.report.mapper.InspectReportMapper;
import com.ruoyi.psi.sale.collection.mapper.CollectionMapper;
import com.ruoyi.psi.sale.delivery.mapper.SaleDeliveryMapper;
import com.ruoyi.psi.sale.order.mapper.SaleOrderMapper;
import com.ruoyi.psi.sale.salereturn.mapper.SaleReturnMapper;
import com.ruoyi.utils.RegularExpression;
import com.ruoyi.utils.UtilsList;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class IdUtilImpl implements IdUtil{
    @Autowired
    private CustomerEventMapper customerEventMapper; //客户事件
    @Autowired
    private CostApportionmentMapper costApportionmentMapper; //费用分摊
    @Autowired
    private FollowRecordMapper followRecordMapper; //跟进记录
    @Autowired
    private SaleOrderMapper saleOrderMapper; //销售订单
    @Autowired
    private SaleDeliveryMapper saleDeliveryMapper; //销售出库
    @Autowired
    private CollectionMapper collectionMapper; //销售收款
    @Autowired
    private SaleReturnMapper saleReturnMapper; //销售退货
    @Autowired
    private PurchaseApplyMapper purchaseApplyMapper; //采购申请
    @Autowired
    private PurchaseOrderMapper purchaseOrderMapper; //采购订单
    @Autowired
    private PurchasePayMapper purchasePayMapper; //采购付款
    @Autowired
    private PurchaseReturnMapper purchaseReturnMapper; //采购退回
    @Autowired
    private PurchaseStorageMapper purchaseStorageMapper; //采购入库
    @Autowired
    private InventoryCheckMapper inventoryCheckMapper; //库存盘点
    @Autowired
    private InventoryInMapper inventoryInMapper; //其他入库
    @Autowired
    private InventoryOutMapper inventoryOutMapper; //其他出库
    @Autowired
    private InventoryTransferMapper inventoryTransferMapper; //库存调拨
    @Autowired
    private ProducePlanSelfMapper producePlanSelfMapper; //生产计划
    @Autowired
    private ProduceWorkSheetMapper produceWorkSheetMapper; //加工单
    @Autowired
    private ReceivingReportMapper receivingReportMapper; //验收单
    @Autowired
    private ProducePlanOutsourceMapper producePlanOutsourceMapper; //委外生产计划
    @Autowired
    private ProduceOfferMapper produceOfferMapper; //生产报价
    @Autowired
    private ProduceMaterialMapper produceMaterialMapper; //领退补料
    @Autowired
    private CustomerOfferMapper customerOfferMapper; //客户报价
    @Autowired
    private SupplierOfferMapper supplierOfferMapper; //供应商报价
    @Autowired
    private LeaveMapper leaveMapper; //请假单
    @Autowired
    private StockInRecordMapper stockInRecordMapper; //入库记录
    @Autowired
    private StockOutRecordMapper stockOutRecordMapper; //出库记录
    @Autowired
    private InspectReportMapper inspectReportMapper; //质检报告
    @Autowired
    private CostAccountingMapper costAccountingMapper; //成本结算
    @Autowired
    private FileMapper fileMapper; //文件

    /**
     * 生成最新的一条客户事件编号
     * KHSJ+8位日期+3位数字
     * @return
     */
    @Override
    public String createEventId() {
        String eventId = customerEventMapper.getEventId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(eventId)) {
            eventId = UtilsList.getFirstId("SJ");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(eventId);
            eventId = UtilsList.getId("SJ", filterStr);
        }
        return eventId;
    }

    /**
     * 生成最新的一条费用分摊编号
     * CBFT+8位日期+3位数字
     * @return
     */
    @Override
    public String createCostApportionmentId() {
        String costApportionmentId = costApportionmentMapper.getCostApportionmentId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(costApportionmentId)) {
            costApportionmentId = UtilsList.getFirstId("CBFT");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(costApportionmentId);
            costApportionmentId = UtilsList.getId("CBFT", filterStr);
        }
        return costApportionmentId;
    }

    /**
     * 生成最新的一条跟进记录编号
     * GJ+8位日期+2位数字
     * @return
     */
    @Override
    public String createFollowId() {
        String followId = followRecordMapper.getFollowId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(followId)) {
            followId = UtilsList.getFirstId("GJ");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(followId);
            followId = UtilsList.getId("GJ", filterStr);
        }
        return followId;
    }

    /**
     * 生成最新销售订单编号
     * XSDD+8位日期+3位数字
     * YCDD+8位日期+3位数字
     * @return
     */
    @Override
    public String createSaleOrderId(String saleOrderType) {
        String saleOrderId = saleOrderMapper.getSaleOrderId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(saleOrderId)) {
            if (saleOrderType.equals("0")) {
                // 销售订单
                saleOrderId = UtilsList.getFirstId("XSDD");
            } else {
                // 预测订单
                saleOrderId = UtilsList.getFirstId("YCDD");
            }
        } else {
            // 数据库里有字段，取出来判断
            if (saleOrderType.equals("0")) {
                // 销售订单
                String filterStr = RegularExpression.filterEnglishLetters(saleOrderId);
                saleOrderId = UtilsList.getId("XSDD", filterStr);
            } else {
                // 预测订单
                String filterStr = RegularExpression.filterEnglishLetters(saleOrderId);
                saleOrderId = UtilsList.getId("YCDD", filterStr);
            }
        }
        return saleOrderId;
    }

    /**
     * 生成最新销售出库编号
     * XSCK+8位日期+3位数字
     *
     * @return
     */
    @Override
    public String createSaleDeliveryId() {
        String saleDeliveryId = saleDeliveryMapper.getSaleDeliveryId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(saleDeliveryId)) {
            saleDeliveryId = UtilsList.getFirstId("XSCK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(saleDeliveryId);
            saleDeliveryId = UtilsList.getId("XSCK", filterStr);
        }
        return saleDeliveryId;
    }

    /**
     * 生成最新销售收款编号
     * XSSK+8位日期+3位数字
     * @return
     */
    @Override
    public String createCollectionId() {
        String saleCollectionId = collectionMapper.getCollectionId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(saleCollectionId)) {
            saleCollectionId = UtilsList.getFirstId("XSSK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(saleCollectionId);
            saleCollectionId = UtilsList.getId("XSSK", filterStr);
        }
        return saleCollectionId;
    }

    /**
     * 生成最新销售退货编号
     * XSTH+8位日期+3位数字
     *
     * @return
     */
    @Override
    public String createSaleReturnId() {
        String saleReturnId = saleReturnMapper.getSaleReturnId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(saleReturnId)) {
            saleReturnId = UtilsList.getFirstId("XSTH");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(saleReturnId);
            saleReturnId = UtilsList.getId("XSTH", filterStr);
        }
        return saleReturnId;
    }

    /**
     * 生成最新采购申请编号
     * CGJH+8位日期+3位数字
     * @return
     */
    @Override
    public String createPurchaseApplyId() {
        String purchaseApplyId = purchaseApplyMapper.getPurchaseApplyId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(purchaseApplyId)) {
            purchaseApplyId = UtilsList.getFirstId("CGJH");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(purchaseApplyId);
            purchaseApplyId = UtilsList.getId("CGJH", filterStr);
        }
        return purchaseApplyId;
    }

    /**
     * 生成最新采购订单编号
     * CG+8位日期+3位数字
     * @return
     */
    @Override
    public String createPurchaseOrderId() {
        String purchaseOrderId = purchaseOrderMapper.getPurchaseOrderId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(purchaseOrderId)) {
            purchaseOrderId = UtilsList.getFirstId("CG");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(purchaseOrderId);
            purchaseOrderId = UtilsList.getId("CG", filterStr);
        }
        return purchaseOrderId;
    }

    /**
     * 生成最新采购付款编号
     * CGFK + 8位日期 + 3位自增
     * @return
     */
    @Override
    public String createPurchasePayId() {
        String purchasePayId = purchasePayMapper.getPurchasePayId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(purchasePayId)) {
            purchasePayId = UtilsList.getFirstId("CGFK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(purchasePayId);
            purchasePayId = UtilsList.getId("CGFK", filterStr);
        }
        return purchasePayId;
    }

    /**
     * 生成最新采购退货编号
     * CGTH+8位日期+3位数字
     *
     * @return
     */
    @Override
    public String createPurchaseReturnId() {
        String purchaseReturnId = purchaseReturnMapper.getPurchaseReturnId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(purchaseReturnId)) {
            purchaseReturnId = UtilsList.getFirstId("CGTH");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(purchaseReturnId);
            purchaseReturnId = UtilsList.getId("CGTH", filterStr);
        }
        return purchaseReturnId;
    }

    /**
     * 生成最新采购入库编号
     * CGRK+8位日期+3位数字
     *
     * @return
     */
    @Override
    public String createPurchaseStorageId() {
        String purchaseStorageId = purchaseStorageMapper.getPurchaseStorageId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(purchaseStorageId)) {
            purchaseStorageId = UtilsList.getFirstId("CGRK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(purchaseStorageId);
            purchaseStorageId = UtilsList.getId("CGRK", filterStr);
        }
        return purchaseStorageId;
    }

    /**
     * 生成最新仓库盘点编号
     * KCPD+8位日期+3位数字
     * @return
     */
    @Override
    public String createInventoryCheckId() {
        String inventoryCheckId = inventoryCheckMapper.getInventoryCheckId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(inventoryCheckId)) {
            inventoryCheckId = UtilsList.getFirstId("KCPD");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(inventoryCheckId);
            inventoryCheckId = UtilsList.getId("KCPD", filterStr);
        }
        return inventoryCheckId;
    }

    /**
     * 生成最新其他入库编号
     * QTRK+8位日期+3位数字
     * @return
     */
    @Override
    public String createInventoryInId() {
        String inventoryInId = inventoryInMapper.getInventoryInId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(inventoryInId)) {
            inventoryInId = UtilsList.getFirstId("QTRK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(inventoryInId);
            inventoryInId = UtilsList.getId("QTRK", filterStr);
        }
        return inventoryInId;
    }

    /**
     * 生成最新其他出库编号
     * QTCK+8位日期+3位数字
     * @return
     */
    @Override
    public String createInventoryOutId() {
        String inventoryOutId = inventoryOutMapper.getInventoryOutId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(inventoryOutId)) {
            inventoryOutId = UtilsList.getFirstId("QTCK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(inventoryOutId);
            inventoryOutId = UtilsList.getId("QTCK", filterStr);
        }
        return inventoryOutId;
    }

    /**
     * 生成最新的一条库存调拨编号
     * KCDB+8位日期+2位数字
     * @return
     */
    @Override
    public String createInventoryTransferId() {
        String inventoryTransferId = inventoryTransferMapper.getInventoryTransferId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(inventoryTransferId)) {
            inventoryTransferId = UtilsList.getFirstId("KCDB");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(inventoryTransferId);
            inventoryTransferId = UtilsList.getId("KCDB", filterStr);
        }
        return inventoryTransferId;
    }

    /**
     * 生成最新自产生产计划编号
     * SCJH+8位日期+3位数字
     *
     * @return
     */
    @Override
    public String createProducePlanSelfId() {
        String producePlanSelfId = producePlanSelfMapper.getProducePlanSelfId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(producePlanSelfId)) {
            producePlanSelfId = UtilsList.getFirstId("SCJH");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(producePlanSelfId);
            producePlanSelfId = UtilsList.getId("SCJH", filterStr);
        }
        return producePlanSelfId;
    }

    /**
     * 生成最新的一条加工单编号
     * JGD+8位日期+3位数字
     * @return
     */
    @Override
    public String createWorkSheetId() {
        String workSheetId = produceWorkSheetMapper.getWorkSheetId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(workSheetId)) {
            workSheetId = UtilsList.getFirstId("JGD");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(workSheetId);
            workSheetId = UtilsList.getId("JGD", filterStr);
        }
        return workSheetId;
    }

    /**
     * 生成最新生产验收入库编号
     * RSD+8位日期+3位数字
     *
     * @return
     */
    @Override
    public String createReceivingReportId() {
        String receivingReportId = receivingReportMapper.getReceivingReportId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(receivingReportId)) {
            receivingReportId = UtilsList.getFirstId("YSD");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(receivingReportId);
            receivingReportId = UtilsList.getId("YSD", filterStr);
        }
        return receivingReportId;
    }

    /**
     * 生成最新的一条委外生产计划编号
     * WWDD+8位日期+2位数字
     * @return
     */
    @Override
    public String createPlanOutsourceId() {
        String planOutsourceId = producePlanOutsourceMapper.getPlanOutsourceId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(planOutsourceId)) {
            planOutsourceId = UtilsList.getFirstId("WWDD");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(planOutsourceId);
            planOutsourceId = UtilsList.getId("WWDD", filterStr);
        }
        return planOutsourceId;
    }

    /**
     * 生成最新生产报价编号
     * @return
     */
    @Override
    public String createProduceOfferId() {
        String produceOfferId = produceOfferMapper.getProduceOfferId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(produceOfferId)) {
            produceOfferId = UtilsList.getFirstId("SCBJ");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(produceOfferId);
            produceOfferId = UtilsList.getId("SCBJ", filterStr);
        }
        return produceOfferId;
    }

    /**
     * 生成最新物料领、补、退编号
     * 领:LLD+8位日期+3位数字
     * 补:BLD+8位日期+3位数字
     * 退:TLD+8位日期+3位数字
     *
     * @return
     */
    @Override
    public String createMaterialRequisitionId(String materialRequisitionType) {
//        System.out.println("单据类型" + materialRequisitionType);
        String materialRequisitionId = produceMaterialMapper.getMaterialRequisitionId(materialRequisitionType);
        switch (materialRequisitionType) {
            //1:领料 2:补料 3:退料
            case "1":
                // 判断是否数据库中是否为空，如果为空，生成第一条编号
                if (StringUtils.isNull(materialRequisitionId)) {
                    materialRequisitionId = UtilsList.getFirstId("LLD");
                } else {
                    // 数据库里有字段，取出来判断
                    String filterStr = RegularExpression.filterEnglishLetters(materialRequisitionId);
                    materialRequisitionId = UtilsList.getId("LLD", filterStr);
                }
                break;
            case "2":
                // 判断是否数据库中是否为空，如果为空，生成第一条编号
                if (StringUtils.isNull(materialRequisitionId)) {
                    materialRequisitionId = UtilsList.getFirstId("BLD");
                } else {
                    // 数据库里有字段，取出来判断
                    String filterStr = RegularExpression.filterEnglishLetters(materialRequisitionId);
                    materialRequisitionId = UtilsList.getId("BLD", filterStr);
                }
                break;
            case "3":
                // 判断是否数据库中是否为空，如果为空，生成第一条编号
                if (StringUtils.isNull(materialRequisitionId)) {
                    materialRequisitionId = UtilsList.getFirstId("TLD");
                } else {
                    // 数据库里有字段，取出来判断
                    String filterStr = RegularExpression.filterEnglishLetters(materialRequisitionId);
                    materialRequisitionId = UtilsList.getId("TLD", filterStr);
                }
                break;
        }
//        System.out.println("生成的id" + materialRequisitionId);
        return materialRequisitionId;

    }

    /**
     * 生成最新客户报价编号
     * KHBJ+8位日期+3位数字
     * @return
     */
    @Override
    public String createCustomerQuotaId() {
        String customerQuotaId = customerOfferMapper.getCustomerQuotaId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(customerQuotaId)) {
            customerQuotaId = UtilsList.getFirstId("KHBJ");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(customerQuotaId);
            customerQuotaId = UtilsList.getId("KHBJ", filterStr);
        }
        return customerQuotaId;
    }

    /**
     * 生成最新供应商报价编号
     * GYSBJ+8位日期+3位数字
     * @return
     */
    @Override
    public String createSupplierQuotaId() {
        String supplierQuotaId = supplierOfferMapper.getSupplierQuotaId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(supplierQuotaId)) {
            supplierQuotaId = UtilsList.getFirstId("GYSBJ");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(supplierQuotaId);
            supplierQuotaId = UtilsList.getId("GYSBJ", filterStr);
        }
        return supplierQuotaId;
    }

    /**
     * 生成最新请假单据
     * J+8位日期+3位数字
     * @return
     */
    @Override
    public String createLeaveId() {
        String leaveId = leaveMapper.getLeaveId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(leaveId)) {
            leaveId = UtilsList.getFirstId("J");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(leaveId);
            leaveId = UtilsList.getId("J", filterStr);
        }
        return leaveId;
    }

    /**
     * 生成最新入库编号
     * RK+8位日期+3位数字
     * @return
     */
    @Override
    public String createStockInId() {
        String stockInId = stockInRecordMapper.getStockInId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(stockInId)) {
            stockInId = UtilsList.getFirstId("RK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(stockInId);
            stockInId = UtilsList.getId("RK", filterStr);
        }
        return stockInId;
    }

    /**
     * 生成最新出库编号
     * CK+8位日期+3位数字
     * @return
     */
    @Override
    public String createStockOutId() {
        String stockOutId = stockOutRecordMapper.getStockOutId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(stockOutId)) {
            stockOutId = UtilsList.getFirstId("CK");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(stockOutId);
            stockOutId = UtilsList.getId("CK", filterStr);
        }
        return stockOutId;
    }

    /**
     * 生成最新质检报告编号
     * ZJ+8位日期+3位数字
     * @return
     */
    @Override
    public String createInspectReportId() {
        String inspectReportId = inspectReportMapper.getInspectReportId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(inspectReportId)) {
            inspectReportId = UtilsList.getFirstId("ZJ");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(inspectReportId);
            inspectReportId = UtilsList.getId("ZJ", filterStr);
        }
        return inspectReportId;
    }

    /**
     * 生成成本结算编号
     * CBJS+8位日期+3位数字
     * @return
     */
    @Override
    public String createCostAccountingId() {
        String costAccountingId = costAccountingMapper.getCostAccountingId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(costAccountingId)) {
            costAccountingId = UtilsList.getFirstId("CBJS");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(costAccountingId);
            costAccountingId = UtilsList.getId("CBJS", filterStr);
        }
        return costAccountingId;
    }

    /**
     * 生成最新的文件编号
     * WJ + 8位日期 + 3位数字
     * @return
     */
    @Override
    public String createFileId() {
        String fileId = fileMapper.getFileId();
        // 判断是否数据库中是否为空，如果为空，生成第一条编号
        if (StringUtils.isNull(fileId)) {
            fileId = UtilsList.getFirstId("WJ");
        } else {
            // 数据库里有字段，取出来判断
            String filterStr = RegularExpression.filterEnglishLetters(fileId);
            fileId = UtilsList.getId("WJ", filterStr);
        }
        return fileId;
    }
}
